Tackling Os Complexity with Declarative Techniques

This thesis argues that tackling the increased operating systems complexity with declarative techniques significantly reduces code complexity involved in adapting to a wide range of modern hardware. Modern hardware is increasingly diverse and complex. It is likely that this trend continues further. This trend complicates the operating systems construction. Operating systems have to adapt to the hardware architecture and exploit all features to guarantee the best possible overall system performance. Not exploiting all hardware features or using them in a suboptimal or even wrong way results in lower overall system performance. Traditionally, operating systems adapt to the underlying architecture by predefined policies, which are intermangled with the core operating systems functionality. In this thesis I argue that it is not anymore possible to encode predefined policies for a set of known hardware architectures into the operating system for two reasons. First, predefined policies do not automatically guarantee that hardware features are fully exploited on all hardware platforms. Second, for this reason, predefined policies would need to be ported to many different hardware platforms, while, at the same time, it would be necessary to keep the policies suited for older platforms. This leads to significant operating systems complexity and finally to high engineering effort, when porting the operating system to new hardware platforms. To avoid this problem, the operating systems must gain hardware knowledge at runtime and derive policies suitable for the current architecture through online reasoning about the hardware. This leads to simpler, better understandable, more maintainable and easier portable operating systems code, while ensuring that the operating system exploits the hardware features as best as possible. Reasoning about hardware and deriving policies is a complex task. This is especially the case, if low-level languages like C are used. Instead, declarative techniques allow to derive policies through a simple description of how to adapt to the hardware based on hardware knowledge gathered at runtime. The natural description in a high-level declarative language reduces code complexity significantly. To prove the usefulness of declarative techniques in the context of adaptability of operating systems and handling of complexity, I present several case studies in this thesis. The case studies are based on declarative techniques. They reason about hardware and derive policies based on hardware knowledge. The case studies do not assume any a priori knowledge about the current hardware platform. Instead, they gain knowledge at runtime by online reasoning about the hardware. A central knowledge service stores hardware knowledge and allows to derive policies according to declarative rules. Because the case studies, and therefore the operating system components, can use the central service, their complexity is again reduced significantly. It is not necessary, that every single component deals with knowledge gathering and deriving policies by itself. It pushes this part to the knowledge service. With this implementation I prove the practical feasibility of applying declarative techniques in real operating systems.